JavaScript Temporal Duration: Ajaintervallide Arvutuste Meisterlik Valdamine

JavaScripti Temporal API tutvustab kaasaegset ja võimsat viisi kuupäevade, kellaaegade ja ajaintervallide käsitlemiseks. Temporal.Duration objekt esindab ajapikkust, pakkudes selget ja intuitiivset lähenemist ajaintervallidega arvutuste tegemiseks. See artikkel süveneb Temporal.Duration'i üksikasjadesse, näidates, kuidas luua, manipuleerida ja vormindada kestusi erinevate kasutusjuhtude jaoks.

Mis on Temporal.Duration?

Temporal.Duration esindab ajavahemikku, väljendades seda aastates, kuudes, päevades, tundides, minutites, sekundites ja sekundi murdosades (millisekundid, mikrosekundid, nanosekundid). Erinevalt Date objektidest, mis esindavad kindlat ajahetke, esindab Temporal.Duration ajahulka. See järgib ISO 8601 kestuse vormingut (nt P1Y2M10DT2H30M tähendab 1 aastat, 2 kuud, 10 päeva, 2 tundi ja 30 minutit). Temporal API on loodud olema intuitiivsem ja vähem vigadealdis kui pärandobjekt Date.

Temporal.Duration Objektide Loomine

Temporal.Duration objekte saab luua mitmel viisil:

1. Lihtobjektist

Kestuse saate luua, edastades objekti soovitud omadustega:

            const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // Väljund: P1Y2M10DT2H30M
            

              
                Copy
              
            
          

See loob kestuse 1 aasta, 2 kuud, 10 päeva, 2 tundi ja 30 minutit. Pange tähele, et argumendid vastavad järgmisele järjekorrale: aastad, kuud, nädalad, päevad, tunnid, minutid, sekundid, millisekundid, mikrosekundid, nanosekundid.

2. ISO 8601 Sõnest

Samuti saate luua kestuse ISO 8601 kestuse sõnest, kasutades Temporal.Duration.from():

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.toString()); // Väljund: P1Y2M10DT2H30M

            

              
                Copy
              
            
          

See on eriti kasulik, kui tegelete kestustega, mis on salvestatud sõne vormingus või saadud välisest allikast.

3. Kasutades meetodeid add() ja subtract() koos Temporal.Instant, Temporal.ZonedDateTime jne.

Kui liidate või lahutate Temporal.Duration teistest Temporal tüüpidest (nagu Temporal.Instant või Temporal.ZonedDateTime), tagastatakse Temporal.Duration, mis esindab nende kahe ajahetke vahet, kui te need seejärel lahutate. Näiteks:

            const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ hours: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Väljund: PT5H
            

              
                Copy
              
            
          

Kestuse Komponentidele Juurdepääs

Temporal.Duration objekti üksikutele komponentidele pääseb juurde selle omaduste kaudu:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // Väljund: 1
console.log(duration.months);     // Väljund: 2
console.log(duration.days);       // Väljund: 10
console.log(duration.hours);      // Väljund: 2
console.log(duration.minutes);     // Väljund: 30
console.log(duration.seconds);     // Väljund: 0
console.log(duration.milliseconds); // Väljund: 0
console.log(duration.microseconds); // Väljund: 0
console.log(duration.nanoseconds);  // Väljund: 0

            

              
                Copy
              
            
          

Aritmeetika Teostamine Kestustega

Temporal.Duration objektid toetavad liitmist ja lahutamist, kasutades meetodeid add() ja subtract(). Need meetodid tagastavad uue Temporal.Duration objekti, mis esindab tehte tulemust.

            const duration1 = Temporal.Duration.from("P1Y2M");
const duration2 = Temporal.Duration.from("P3M4D");

const addedDuration = duration1.add(duration2);
console.log(addedDuration.toString()); // Väljund: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // Väljund: P10M26D

            

              
                Copy
              
            
          

Keerukamate arvutuste tegemiseks saate neid meetodeid ka aheldada:

            const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // Väljund: P1DT11H30M

            

              
                Copy
              
            
          

Meetod negated() tagastab uue Temporal.Duration objekti, mille kõik komponendid on vastandmärgiga:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Väljund: -P1Y2M10DT2H30M

            

              
                Copy
              
            
          

Meetod abs() tagastab uue Temporal.Duration objekti, mille kõik komponendid on positiivsete väärtustega (absoluutväärtused):

            const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Väljund: P1Y2M10DT2H30M

            

              
                Copy
              
            
          

Meetod with() võimaldab teil luua uue Temporal.Duration eksemplari, mille mõned või kõik omadused on muudetud uutele väärtustele. Kui argumendi objektis väärtust ei määrata, kasutatakse kestuse algset väärtust. Näiteks:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // Väljund: P2Y2M5DT2H30M
            

              
                Copy
              
            
          

Kestuste Normaliseerimine

Kestusi saab mõnikord väljendada normaliseerimata kujul (nt P1Y12M, mida saaks lihtsustada kujule P2Y). Meetod normalized() üritab kestust lihtsustada selle kõige kompaktsemale kujule. Kuid see nõuab võrdluskuupäeva, et tulla toime erinevate kuude pikkuste keerukusega. Korralikuks normaliseerimiseks vajate Temporal.PlainDate, Temporal.ZonedDateTime või Temporal.Instant eksemplari.

Näiteks kuud ja päevi sisaldava kestuse normaliseerimine nõuab võrdluskuupäeva:

            const duration = Temporal.Duration.from("P1M32D");
const referenceDate = Temporal.PlainDate.from("2024-01-01");
const normalizedDuration = duration.normalized({ relativeTo: referenceDate });
console.log(normalizedDuration.toString()); // Väljund: P2M1D

            

              
                Copy
              
            
          

Selles näites on kestus P1M32D normaliseeritud 1. jaanuari 2024 suhtes, mille tulemuseks on P2M1D, kuna jaanuaris on 31 päeva.

Kui tegelete ainult aja komponentidega (tunnid, minutid, sekundid jne), saate normaliseerida ilma võrdluskuupäevata:

            const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //või jätke relativeTo argument ära
console.log(normalizedDuration.toString()); // Väljund: P1DT2H1M

            

              
                Copy
              
            
          

Kestuste Võrdlemine

Kestusi saate võrrelda meetodiga compare(). See meetod tagastab:

• -1, kui esimene kestus on lühem kui teine kestus.
• 0, kui kestused on võrdsed.
• 1, kui esimene kestus on pikem kui teine kestus.

            const duration1 = Temporal.Duration.from("P1Y");
const duration2 = Temporal.Duration.from("P6M");

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // Väljund: 1

            

              
                Copy
              
            
          

Praktilised Näited

1. Sündmuseni Jäänud Aja Arvutamine

Oletame, et soovite arvutada konkreetse sündmuseni jäänud aega. Kasutades praeguse aja saamiseks Temporal.Now.zonedDateTimeISO() ja lahutades sündmuse kuupäeva. Kui sündmuse kuupäev on möödas, on väljund negatiivne.

            const eventDate = Temporal.ZonedDateTime.from({ timeZone: 'America/Los_Angeles', year: 2024, month: 12, day: 25, hour: 9, minute: 0, second: 0 });
const now = Temporal.Now.zonedDateTimeISO('America/Los_Angeles');

const durationUntilEvent = eventDate.since(now);

console.log(durationUntilEvent.toString()); // Väljund: nt P262DT14H30M (sõltuvalt praegusest kuupäevast ja kellaajast)
            

              
                Copy
              
            
          

2. Projekti Ülesannete Kestuste Jälgimine

Projektijuhtimises saate kasutada Temporal.Duration'i ülesannete hinnangulise või tegeliku kestuse jälgimiseks.

            const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 tundi
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 tundi

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Hinnanguline kogukestus: ${totalEstimatedDuration.toString()}`); // Väljund: Hinnanguline kogukestus: P1DT
            

              
                Copy
              
            
          

3. Vanuse Arvutamine

Kuigi vanuse täpne arvutamine nõuab liigaastate ja ajavööndite arvessevõtmist, võib Temporal.Duration anda mõistliku hinnangu:

            const birthDate = Temporal.PlainDate.from("1990-05-15");
const currentDate = Temporal.PlainDate.from("2024-01-20");

const ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Hinnanguline vanus: ${ageDuration.years} aastat`); // Väljund: Hinnanguline vanus: 33 aastat
            

              
                Copy
              
            
          

4. Inimloetavate Kestuste Kuvamine

Sageli peate kuvama kestusi inimloetavas vormingus. Kuigi Temporal.Duration'il pole sisseehitatud vormindamisfunktsioone, saate luua kohandatud vormindamisloogika:

            function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} aasta${duration.years > 1 ? 't' : ''}`);
  if (duration.months) parts.push(`${duration.months} kuu${duration.months > 1 ? 'd' : ''}`);
  if (duration.days) parts.push(`${duration.days} päev${duration.days > 1 ? 'a' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} tund${duration.hours > 1 ? 'i' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} minut${duration.minutes > 1 ? 'it' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} sekund${duration.seconds > 1 ? 'it' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Väljund: 1 aasta, 2 kuud, 10 päeva, 2 tundi, 30 minutit
            

              
                Copy
              
            
          

Täpsem Kasutus ja Kaalutlused

1. Ajavööndite Käsitlemine

Kui tegelete ajaintervallidega, mis ületavad ajavööndi piire või suveaja üleminekuid, on täpsete arvutuste tagamiseks ülioluline kasutada Temporal.ZonedDateTime'i. Temporal.PlainDate'i ja Temporal.PlainTime'i kasutamine väldib ajavööndite teisendusi.

2. Vähim Ühik ja Ümardamine

Meetodid `since()` ja `until()` aktsepteerivad sageli valikuid tulemuseks oleva kestuse vähima ühiku määramiseks. Näiteks sündmuseni jäänud aja arvutamine ja tulemuste piiramine päevadeni.

            const eventDate = Temporal.PlainDate.from("2024-12-25");
const now = Temporal.PlainDate.from("2024-01-20");

const durationUntilEvent = now.until(eventDate, { smallestUnit: 'days' });

console.log(durationUntilEvent.toString()); //näidisväljund PT340D
            

              
                Copy
              
            
          

3. Liigsekundid

Temporal ei arvesta liigsekundeid loomupäraselt. Kui vajate äärmist täpsust, peate liigsekundeid eraldi käsitlema.

4. IANA Ajavööndid

Temporal API tugineb IANA (Internet Assigned Numbers Authority) ajavööndite andmebaasile. Veenduge, et teie keskkonnas oleks ajakohane IANA andmebaasi versioon, et ajavööndite teisendusi täpselt käsitleda.

Parimad Praktikad

• Kasutage kestuse sõnede jaoks ISO 8601 vormingut: See tagab järjepidevuse ja koostalitlusvõime.
• Valige sobiv Temporal tüüp: Kasutage Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime või Temporal.Instant sõltuvalt sellest, kas vajate ajavööndi tuge või mitte.
• Vajadusel normaliseerige kestused: Normaliseerimine lihtsustab kestusi ja muudab nende võrdlemise lihtsamaks.
• Käsitsege ajavööndeid hoolikalt: Ajavööndite teisendused võivad olla keerulised, seega kasutage Temporal.ZonedDateTime'i ja olge teadlik suveaja üleminekutest.
• Arvestage vähima ühikuga: Kestuste arvutamisel määrake vähim ühik soovitud täpsustaseme saavutamiseks.
• Kirjutage ühikteste: Testige oma koodi põhjalikult, et tagada kestuse arvutuste täpsus.

Levinud Lõksud

• Ajavööndite ignoreerimine: Ajavööndite arvesse võtmata jätmine võib põhjustada valesid kestuse arvutusi, eriti kui tegemist on sündmustega erinevates asukohtades.
• Pärandobjekti Date kasutamine: Pärandobjekt Date on tuntud oma veidruste ja ebajärjekindluse poolest. Eelistage usaldusväärsemaks kuupäeva ja kellaaja käsitlemiseks Temporal API-d.
• Kestuste normaliseerimata jätmine: Kestuste normaliseerimata jätmine võib muuta võrdlused ja arvutused keerukamaks.
• Vale ISO 8601 vorming: Kehtetu ISO 8601 kestuse sõne kasutamine võib põhjustada vigu.

Reaalse Maailma Kasutusjuhud Erinevates Kultuurides

Temporal API võib olla eriti kasulik globaalsetes rakendustes, kus ajavööndite erinevused ja kultuurilised nüansid on olulised. Siin on mõned näited:

• Ülemaailmne Sündmuste Planeerimine: Sündmuste täpne planeerimine mitmes ajavööndis, võttes arvesse suveaja üleminekuid. Näiteks veebiseminari planeerimine, mis algab kell 9:00 PST ja vastava algusaja kuvamine erinevates ajavööndites nagu CET, JST ja AEDT.
• Rahvusvaheline Reisiplaneerimine: Reisi kestuste arvutamine, sealhulgas vahemaandumised ja ajavööndi muutused. See on kasulik marsruutide koostamiseks ja lennugraafikute haldamiseks. Näiteks kogu reisiaja arvutamine New Yorgist Tokyosse, sealhulgas vahemaandumine Londonis ja ajavööndi erinevuste arvestamine.
• Ülemaailmne E-kaubandus: Hinnanguliste tarneaegade kuvamine kasutaja kohalikus ajavööndis. See nõuab lähtekoha ajavööndi, tarne kestuse ja sihtkoha ajavööndi arvessevõtmist. Näiteks Saksamaa laost Austraalia kliendile saadetud kaup, mille hinnanguline tarneaeg on 7 päeva, kuvatakse kliendi kohalikus ajas.
• Piiriülesed Finantstehingud: Intresside kogunemise või maksetähtaegade täpne arvutamine erinevates piirkondades. See hõlmab sageli erinevate tööpäevade ja pühade arvestamist igas riigis. Näiteks Singapuris laenult kogunenud intresside arvutamine, võttes arvesse Singapuri riigipühi.
• Multikultuursed Kalendrirakendused: Erinevate kalendrisüsteemide, näiteks islami või heebrea kalendri, toetamine ning sündmuste kestuste ja meeldetuletuste täpne arvutamine nende kalendrite põhjal.
• Ülemaailmne Projektijuhtimine: Projekti ülesannete kestuste ja tähtaegade jälgimine hajutatud meeskondades, võttes arvesse erinevaid töögraafikuid ja ajavööndeid.

Kokkuvõte

Temporal.Duration pakub robustset ja intuitiivset viisi ajaintervallidega töötamiseks JavaScriptis. Mõistes selle funktsioone ja parimaid praktikaid, saate oma rakendustes enesekindlalt teostada täpseid ja usaldusväärseid kestuse arvutusi. Temporal API omaksvõtmine viib puhtama, paremini hooldatava koodini ja vähendab pärandkuupäevade ja -aegade käsitlemisega seotud vigade riski.

Süvenedes Temporal API-sse, ärge unustage tutvuda ametliku dokumentatsiooniga ja katsetada erinevaid stsenaariume, et selle võimekust täielikult mõista. Oma kaasaegse disaini ja laiaulatuslike funktsioonidega on Temporal valmis revolutsiooniliselt muutma viisi, kuidas me JavaScriptis kuupäevi, kellaaegu ja kestusi käsitleme.